#!/usr/bin/env node

/**
 * 更新预约数据的首选日期和强制使用首选日期设置
 *
 * 使用方法：
 *   node app/scripts/update-appointment-preferred-date.mjs --name "阮志斌"
 *   node app/scripts/update-appointment-preferred-date.mjs --name "阮志斌" --db-path "C:\path\to\app.db"
 */

import { existsSync } from 'node:fs'
import { dirname, join } from 'node:path'
import { fileURLToPath } from 'node:url'

const __filename = fileURLToPath(import.meta.url)
const __dirname = dirname(__filename)
const projectRoot = join(__dirname, '..')

async function main() {
  // 解析命令行参数
  let specifiedName = null
  let specifiedDbPath = null

  for (let i = 2; i < process.argv.length; i++) {
    const arg = process.argv[i]
    if (arg === '--name' && i + 1 < process.argv.length) {
      specifiedName = process.argv[i + 1]
      i++
    }
    else if (arg === '--db-path' && i + 1 < process.argv.length) {
      specifiedDbPath = process.argv[i + 1]
      i++
    }
  }

  if (!specifiedName) {
    console.error('❌ 请指定要更新的姓名')
    console.error('使用方法: node app/scripts/update-appointment-preferred-date.mjs --name "姓名"')
    process.exit(1)
  }

  // 初始化数据库
  console.log('正在初始化数据库...')
  const { PrismaClient } = await import('@prisma/client')

  let dbPath = null

  // 如果用户指定了数据库路径，直接使用
  if (specifiedDbPath) {
    if (existsSync(specifiedDbPath)) {
      dbPath = specifiedDbPath
      console.log(`使用指定的数据库文件: ${dbPath}`)
    }
    else {
      console.error(`❌ 指定的数据库文件不存在: ${specifiedDbPath}`)
      process.exit(1)
    }
  }
  else {
    // 尝试多个可能的数据库路径（优先使用生产环境）
    const possibleDbPaths = []

    // 如果是Windows，优先使用生产环境路径
    if (process.platform === 'win32') {
      // 优先使用生产环境实际路径
      possibleDbPaths.push('C:\\Users\\Administrator\\AppData\\Roaming\\AutoTools\\data\\app.db')

      const appData = process.env.APPDATA || process.env.LOCALAPPDATA
      if (appData) {
        // 使用AutoTools（生产环境实际使用的路径）
        possibleDbPaths.push(join(appData, 'AutoTools', 'data', 'app.db'))
        // 兼容其他可能的路径
        possibleDbPaths.push(join(appData, 'auto-tools', 'data', 'app.db'))
      }
    }

    // 最后尝试开发环境：项目目录下的数据库
    possibleDbPaths.push(join(projectRoot, 'prisma', 'data', 'app.db'))

    // 查找存在的数据库文件（按优先级顺序）
    console.log('正在查找数据库文件（按优先级）...')
    for (const path of possibleDbPaths) {
      if (existsSync(path)) {
        dbPath = path
        console.log(`✅ 找到数据库文件: ${dbPath}`)
        break
      }
      else {
        console.log(`  ⚠️  不存在: ${path}`)
      }
    }

    if (!dbPath) {
      console.error('\n❌ 未找到数据库文件，尝试了以下路径:')
      possibleDbPaths.forEach(p => console.error(`  - ${p}`))
      console.error('\n提示: 可以使用 --db-path 参数指定数据库文件路径')
      process.exit(1)
    }
  }

  const dbUrl = `file:${dbPath.replace(/\\/g, '/')}`
  process.env.DATABASE_URL = dbUrl

  const prisma = new PrismaClient({
    datasources: {
      db: { url: dbUrl },
    },
  })

  // 启用 WAL 模式
  try {
    await prisma.$executeRawUnsafe('PRAGMA journal_mode=WAL;')
    await prisma.$executeRawUnsafe('PRAGMA synchronous=NORMAL;')
    await prisma.$executeRawUnsafe('PRAGMA busy_timeout=15000;')
  }
  catch {}

  console.log(`✅ 数据库初始化完成: ${dbPath}`)
  console.log()

  try {
    // 查找匹配的记录
    console.log(`正在查找姓名为 "${specifiedName}" 的记录...`)
    const appointments = await prisma.appointment_management.findMany({
      where: {
        full_name: specifiedName,
      },
    })

    if (appointments.length === 0) {
      console.error(`❌ 未找到姓名为 "${specifiedName}" 的记录`)
      await prisma.$disconnect()
      process.exit(1)
    }

    console.log(`✅ 找到 ${appointments.length} 条记录`)
    console.log()

    // 更新每条记录
    let updatedCount = 0
    for (const appointment of appointments) {
      console.log(`正在更新记录 ID: ${appointment.id}`)
      console.log(`  姓名: ${appointment.full_name}`)
      console.log(`  护照号: ${appointment.passport_number}`)
      console.log(`  当前首选日期: ${appointment.preferred_dates || '(空)'}`)
      console.log(`  当前强制使用首选日期: ${appointment.force_preferred_dates}`)

      await prisma.appointment_management.update({
        where: { id: appointment.id },
        data: {
          preferred_dates: null,
          force_preferred_dates: false,
        },
      })

      console.log(`  ✅ 已更新:`)
      console.log(`    首选日期: (空)`)
      console.log(`    是否强制使用首选日期: false`)
      console.log()
      updatedCount++
    }

    console.log(`✅ 成功更新 ${updatedCount} 条记录`)
  }
  catch (error) {
    console.error('❌ 更新失败:', error.message)
    console.error(error)
    await prisma.$disconnect()
    process.exit(1)
  }
  finally {
    await prisma.$disconnect()
  }
}

main().catch((error) => {
  console.error('❌ 脚本执行失败:', error)
  process.exit(1)
})
